package Datos;

import Indexador.FuncionesTexto;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.HashMap;

/**
 *
 * Clase estática para el almacenamiento de temas, simulando una Base de Datos,
 * que será rellenada por el indexador y accedida en búsqueda por el buscador.
 *
 * @author Mikel&Igor
 */
public final class TemasBD
{
    //Contador usado para debug
    private static int contador = 0;
    private static int saved=0;
    private static String pathBD = "/tmp/TemasBD";
    private static HashMap<String,ArrayList<Tema>> map=null;

    /**
     * Almacena un nuevo Tema en la Base de Datos. Para ello comprueba si ya hay
     * algún tema con ese título. Si es así, lo añade a la lista de Temas con ese
     * título, si no, crea uno nuevo.
     * @param tema El tema a almacenar
     */
    public static synchronized void guardarTema(Tema tema)
    {
        //Leemos el hashMap de fichero si es necesario, es decir, si es la primera vez
        if(map==null)
            map = leerHashMap();

        //Para mejorar las búsquedas guardamos el título en minúsculas y sin tildes
        String tituloTema=FuncionesTexto.minusculaSinAcento(tema.getTituloCompleto());

        ArrayList<Tema> arrayTemas=map.get(tituloTema);

        if(arrayTemas!=null) //Si ya hay temas con ese título añadimos el nuevo
        {
            arrayTemas.add(tema);
            map.put(tituloTema, arrayTemas);

        }
        else //Si no existe lo creamos
        {
            arrayTemas=new ArrayList<Tema>();
            arrayTemas.add(tema);
            map.put(tituloTema, arrayTemas);
        }

        System.out.println(">>>>>>"+tema.getTituloCompleto());

        if(saved==0)
        {
            guardarHashMap();
            System.out.println("****Almacenado HashMap: "+map.size()+" componentes distintos****");
        }

        saved++;

        if(saved==100)
            saved=0;

        contador++;
        System.out.println("Almacenados "+contador+" temas en la BD");

    }


    /**
     * Devuelve el HashMap almacenado.
     * @return El HashMap almacenado.
     */
    public static synchronized HashMap<String,ArrayList<Tema>> leerHashMap()
    {
        //El hash map está almacenado en un fichero
        File f=new File(pathBD);
        ObjectInputStream in=null;

        //Si no existe, se crea
        if(!f.exists())
        {
            return new HashMap<String, ArrayList<Tema>>();
        }

        try
        {
            //Si existe lo leemos
            in=new ObjectInputStream(new FileInputStream(f));

            HashMap<String,ArrayList<Tema>> hmap=(HashMap<String,ArrayList<Tema>>) in.readObject();

            return hmap;
        }
        catch(Exception ex)
        {
            System.out.println("Error en la lectura del HashMap " + ex);
            return new HashMap<String, ArrayList<Tema>>();
        }
        finally //En cualquier caso cerramos todo
        {
            try
            {
                if(in!=null)
                    in.close();
            }
            catch(IOException ex)
            {
                System.out.println("Error al cerrar el fichero al leer el HashMap "+ex.getMessage());
            }
        }
    }

    /**
     * Metodo sincronizado utilizado para guardar el hashmap en fichero
     */
    public static synchronized void guardarHashMap()
    {
        FileOutputStream fos=null;
        ObjectOutputStream out=null;

        try
        {
            //Volvemos a guardar el HashMap
            File f = new File(pathBD);
            fos = new FileOutputStream(f);
            out=new ObjectOutputStream(fos);

            out.writeObject(map);

        }
        catch(IOException ex)
        {
            System.out.println("Error en la escritura del HashMap "+ex);
        }
        finally //En cualquier caso cerramos los stream
        {
            try
            {
                if(fos!=null)
                    fos.close();
                if(out!=null)
                    out.close();
            }
            catch(IOException ex)
            {
                System.out.println("Error al guardar el fichero al escribir el HashMap");
            }
        }
    }

    /**
     * Devuelve una lista con todos los temas almacenados en la base de datos
     * cuyos títulos coincidan con el indicado.
     * @param titulo El título de la serie.
     * @return Una lista de Temas o null si no hay ninguno con ese título.
     */
    public static ArrayList<Tema> getTemas(String titulo)
    {
        //Leemos el hashmap
        map=leerHashMap();

        //Cogemos la lista correspondiente al título (minúsculas y sin acentos)
        ArrayList<Tema> lista=map.get(FuncionesTexto.minusculaSinAcento(titulo));

        return lista;
    }
}
